package com.example.markdownmindmap.service;

import com.example.markdownmindmap.entity.MindMapNode;
import com.vladsch.flexmark.ast.Heading;
import com.vladsch.flexmark.util.ast.Node;
import com.vladsch.flexmark.parser.Parser;
import com.vladsch.flexmark.util.ast.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.regex.Pattern;

/**
 * Markdown转思维导图服务类
 */
@Service
public class MarkdownToMindMapService {
    private static final Logger logger = LoggerFactory.getLogger(MarkdownToMindMapService.class);
    
    private final Parser parser;
    // 用于清理Markdown格式的正则表达式
    private static final Pattern MARKDOWN_FORMAT_PATTERN = Pattern.compile("\\*\\*|\n|\\s{2,}");
    
    // 初始化Markdown解析器
    public MarkdownToMindMapService() {
        this.parser = Parser.builder().build();
    }
    /**
     * 将Markdown文本转换为思维导图节点结构
     * @param markdown Markdown文本
     * @param fileName 文件名称
     * @return 思维导图根节点
     */
    public MindMapNode convert(String markdown, String fileName) {
        if (markdown == null || markdown.trim().isEmpty()) {
            return new MindMapNode("空文档");
        }

        // 解析Markdown
        Document document = parser.parse(markdown);

        // 根节点初始名称为空字符串
        String rootName = "";
        MindMapNode root = new MindMapNode(rootName);
        root.setTitleLevel(0);
        root.setDepth(0);
        logger.info("创建根节点: {}", rootName);

        // 使用栈来管理节点层级关系
        Deque<MindMapNode> nodeStack = new ArrayDeque<>();
        nodeStack.push(root);
        
        // 记录上一个标题的级别
        int lastLevel = 1;
        // 遍历所有节点
        // 初始化文档遍历
        Node node = document.getFirstChild();
        while (node != null) {
            // 只处理标题节点
            if (node instanceof Heading) {
                Heading heading = (Heading) node;
                int level = heading.getLevel();
                String text = heading.getText().toString();
                
                // 清理Markdown格式
                text = cleanMarkdownFormat(text);
                
                // 创建当前标题节点
                MindMapNode currentNode = new MindMapNode(text);
                currentNode.setTitleLevel(level);
                logger.info("创建节点: {} (级别: {})", text, level);
                
                // 调整栈，找到合适的父节点
                if (level == 1) {
                    // 弹出所有非根节点
                    while (nodeStack.size() > 1) {
                        nodeStack.pop();
                    }
                } else {

                    // 对于多级标题，根据节点级别调整
                    while (nodeStack.peek().getTitleLevel() >= level) {
                        nodeStack.pop();
                    }
                }
                
                // 添加到父节点
                MindMapNode parentNode = nodeStack.peek();
                
                currentNode.setDepth(parentNode.getDepth()+1);
                parentNode.addChild(currentNode);
                logger.info("添加节点 '{}' 到父节点 '{}' 深度:{}", text, parentNode.getName(),parentNode.getDepth());
                // 将当前节点入栈
                nodeStack.push(currentNode);
                lastLevel = level;
            }
            node = node.getNext();
        }

        // 最终检查：确保根节点名称始终为空字符串
        root.setName("");
        logger.info("根节点名称设置为空字符串");
        
        return root;
    }
    
    /**
     * 清理文本中的Markdown格式
     * @param text 原始文本
     * @return 清理后的文本
     */
    private String cleanMarkdownFormat(String text) {
        // 移除加粗标记(**)、换行符和多余空格
        text = MARKDOWN_FORMAT_PATTERN.matcher(text).replaceAll(" ");
        // 移除首尾空格
        return text.trim();
    }
}
